home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / Priss / source / layer2.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-03-14  |  11.8 KB  |  360 lines
  1. //    Priss (NekoAmp 2.0) - MPEG-1/2 audio decoding library
  2. //    Copyright (C) 2003 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include <math.h>
  19. #include "engine.h"
  20. #include "bitreader.h"
  21.  
  22. // The format of an MPEG layer II frame:
  23. //
  24. // 1) bit allocations for separate subbands (2..4 bits per channel per subband)
  25. // 2) bit allocations for joint subbands (2..4 bits per subband)
  26. // 3) scale factor selector indices (2 bits per channel per subband that has
  27. //    bits allocated)
  28. // 4) scale factors (6-18 bits per channel per subband that has bits allocated,
  29. //                   depending on scale factor selector)
  30. // 5) repeated 12 times:
  31. //    a) samples for seperate subbands (3 x n bits per channel per subband)
  32. //    b) samples for joint subbands (3 x n bits per subband)
  33. //
  34. // There are up to two channels and always 32 subbands.  Channels in the joint
  35. // stereo range share the same samples but may have different scale factors.
  36.  
  37. namespace {
  38.     // bit allocation table rows (ISO 11172-3 Table B.2)
  39.     //
  40.     // These tables tell us how many bits (or which grouping type) to use to
  41.     // decode a subband sample in a subband.  Different subbands have different
  42.     // selections according to the table.
  43.     //
  44.     static const uint8 g_L2BitAllocTableRows[6][16] = {
  45.         {  0, 17,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16 },    // table B.2a, subbands 0-2; table B.2b, subbands 0-2
  46.         {  0, 17, 18,  3, 19,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16 },    // table B.2a, subbands 3-10; table B.2b, subbands 3-10
  47.         {  0, 17, 18,  3, 19,  4,  5, 16 },                                    // table B.2a, subbands 11-22; table B.2b, subbands 11-22
  48.         {  0, 17, 18, 16 },                                                    // table B.2a, subbands 23-26; table B.2b, subbands 23-29
  49.         {  0, 17, 18, 19,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },    // table B.2c, subbands 0-7; table B.2d, subbands 0-11; 13818-3 table B.1, subbands 4-29
  50.         {  0, 17, 18,  3, 19,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14 },    // 13818-3 table B.1, subbands 0-3
  51.     };
  52.  
  53.     // bit allocation table row pointers
  54.     static const struct L2BitAllocTableBand {
  55.         uint8 table_row;        // row from above table to use
  56.         uint8 subband_count;    // number of subbands
  57.         uint8 bits;                // number of bits per subband to index into row
  58.     } g_L2BitAllocTables[5][4]={
  59.         { { 0, 3, 4 }, { 1, 8, 4 }, { 2, 12, 3 }, { 3, 4, 2 } },    // MPEG-1 table A (27 subbands / 88 bits)
  60.         { { 0, 3, 4 }, { 1, 8, 4 }, { 2, 12, 3 }, { 3, 7, 2 } },    // MPEG-1 table B (30 subbands / 94 bits)
  61.         { { 4, 2, 4 }, { 4, 6, 3 } },                                // MPEG-1 table C ( 8 subbands / 26 bits)
  62.         { { 4, 2, 4 }, { 4, 10, 3 } },                                // MPEG-1 table D (12 subbands / 38 bits)
  63.         { { 5, 4, 4 }, { 4, 7, 3 }, { 4, 19, 2 } },                    // MPEG-2 table   (30 subbands / 75 bits)
  64.     };
  65.  
  66.     // bit allocation table selectors, by channels, frequency and bitrate
  67.     static const sint8 g_L2BitAllocTableSelector[2][3][16]={
  68. //            inv, 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384,ff
  69.         {
  70.             {-1,  2,  2,  0,  0,  0,  1,  1,  1,  1,  1, -1, -1, -1, -1, 1 },        // 44.1KHz mono
  71.             {-1,  2,  2,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1, -1, -1, 0 },        // 48KHz mono
  72.             {-1,  3,  3,  0,  0,  0,  1,  1,  1,  1,  1, -1, -1, -1, -1, 1 },        // 32KHz mono
  73.         },
  74.         {
  75.             {-1, -1, -1, -1,  2, -1,  2,  0,  0,  0,  1,  1,  1,  1,  1, 0 },        // 44.1KHz stereo
  76.             {-1, -1, -1, -1,  2, -1,  2,  0,  0,  0,  0,  0,  0,  0,  0, 0 },        // 48KHz stereo
  77.             {-1, -1, -1, -1,  3, -1,  3,  0,  0,  0,  1,  1,  1,  1,  1, 0 },        // 32KHz stereo
  78.         }
  79.     };
  80. };
  81.  
  82. bool VDMPEGAudioDecoder::DecodeLayerII() {
  83.     unsigned    bitalloc[32][2] = {0};        // bit allocations
  84.     uint8        scfsi[32][2];                // scale factor selector indices (32 subbands x 2 channels)
  85.     float        scalefac[3][32][2];            // scale factors (3 parts x 32 subbands x 2 channels)
  86.     unsigned    sb;                            // subband
  87.     unsigned    sblimit;                    // subband limit for decoding
  88.     unsigned    bound = 32;                    // start of joint-stereo or mono decoding
  89.     bool        stereo = mMode != 3;
  90.     bool        is_mpeg2 = mHeader.nMPEGVer > 1;
  91.  
  92.     if (mMode == 1)
  93.         bound = mModeExtension * 4 + 4;
  94.  
  95.     if (!stereo)
  96.         bound = 0;
  97.  
  98.     // reservoir analysis
  99.     //
  100.     // Worst case for layer II is 8Kbps, 48KHz stereo, giving a frame size of
  101.     // 24 bytes, or a data payload of 160 bits.  Well, the MPEG-2 bit allocation
  102.     // table takes 150 bits for two channels, so MPEG-2 bit allocation reading
  103.     // will never overflow.  For MPEG-1, the bound goes up to 32Kbps, raising
  104.     // the payload to 736 bits.  We definitely won't hit that!
  105.  
  106.     VDMPEGAudioBitReader bits(mFrameBuffer, mFrameDataSize);
  107.  
  108.     // select bit allocation table
  109.     int bitalloc_table = is_mpeg2 ? 4 : g_L2BitAllocTableSelector[stereo][mSamplingRateIndex][mBitrateIndex];
  110.  
  111.     if (bitalloc_table < 0)
  112.         throw (int)ERR_INVALIDDATA;        // combination not permitted by standard
  113.  
  114.     // read in bit allocations (max: 188 bits)
  115.     //
  116.     // The bit allocation table has been broken down into four ranges of
  117.     // subbands, each of which has a row type and a number of bits to
  118.     // fetch per subband to index into that row type.
  119.  
  120.     static const uint8 bits_per_sample_triad[]={0,3*1,3*2,3*3,3*4,3*5,3*6,3*7,3*8,3*9,3*10,3*11,3*12,3*13,3*14,3*15,3*16,5,7,10};
  121.  
  122.     unsigned nonzero_s = 0, nonzero_js = 0;
  123.     unsigned total_s = 0, total_js = 0;
  124.  
  125.     sb = 0;
  126.     for(unsigned band=0; band<4; ++band) {
  127.         const L2BitAllocTableBand& bandinfo = g_L2BitAllocTables[bitalloc_table][band];
  128.         const uint8 *bitalloc_row = g_L2BitAllocTableRows[bandinfo.table_row];
  129.  
  130.         for(unsigned i=0; i<bandinfo.subband_count; ++i) {
  131.             bitalloc[sb][0] = bitalloc[sb][1] = bitalloc_row[bits.get(bandinfo.bits)];
  132.  
  133.             if (sb < bound) {
  134.                 bitalloc[sb][1] = bitalloc_row[bits.get(bandinfo.bits)];
  135.  
  136.                 if (bitalloc[sb][0]) {
  137.                     ++nonzero_s;
  138.                     total_s += bits_per_sample_triad[bitalloc[sb][0]];
  139.                 }
  140.  
  141.                 if (bitalloc[sb][1]) {
  142.                     ++nonzero_s;
  143.                     total_s += bits_per_sample_triad[bitalloc[sb][1]];
  144.                 }
  145.             } else {
  146.                 if (bitalloc[sb][0]) {
  147.                     ++nonzero_js;
  148.                     total_js += bits_per_sample_triad[bitalloc[sb][0]];
  149.                 }
  150.             }
  151.  
  152.             ++sb;
  153.         }
  154.     }
  155.     sblimit = sb;
  156.  
  157.     // space check - scalefactor selectors and samples
  158.     //
  159.     // 2 bits per channel per subband with non-zero allocation
  160.  
  161.     unsigned scfsi_bits = 2*nonzero_js;
  162.     
  163.     if (stereo)
  164.         scfsi_bits += 2*(nonzero_s + nonzero_js);
  165.  
  166.     if (!bits.chkavail(scfsi_bits))
  167.         throw (int)ERR_INCOMPLETEFRAME;
  168.  
  169. #ifdef _DEBUG
  170.     const unsigned expected_left_scfsi = bits.avail() - scfsi_bits;
  171. #endif
  172.  
  173.     // read in scalefactor selectors
  174.  
  175.     unsigned scf_total = 0;
  176.  
  177.     static const uint8 bits_per_scfsi[4]={3*6, 2*6, 1*6, 2*6};
  178.  
  179.     if (stereo) {
  180.         for(sb=0; sb<sblimit; ++sb) {
  181.             if (bitalloc[sb][0])
  182.                 scf_total += bits_per_scfsi[scfsi[sb][0] = bits.get(2)];
  183.  
  184.             if (bitalloc[sb][1])
  185.                 scf_total += bits_per_scfsi[scfsi[sb][1] = bits.get(2)];
  186.         }
  187.     } else {
  188.         for(sb=0; sb<sblimit; ++sb) {
  189.             if (bitalloc[sb][0])
  190.                 scf_total += bits_per_scfsi[scfsi[sb][0] = bits.get(2)];
  191.         }
  192.     }
  193.  
  194.     // space check - scalefactors and samples
  195.     //
  196.     // 6 bits per scalefactor, plus 12 granules * 3 samples * total_sample_bits
  197.  
  198.     const unsigned scf_and_samples_bits = scf_total + 12*(total_s + total_js);
  199.     
  200.     if (!bits.chkavail(scf_and_samples_bits))
  201.         throw (int)ERR_INCOMPLETEFRAME;
  202.  
  203. #ifdef _DEBUG
  204.     VDASSERT(bits.avail() == expected_left_scfsi);
  205.  
  206.     const unsigned expected_left = bits.avail() - scf_and_samples_bits;
  207. #endif
  208.  
  209.     // read in scale factors
  210.  
  211.     static const float sL2Dequant[18]={
  212.         2.0f / 7.0f,
  213.         2.0f / 15.0f,
  214.         2.0f / 31.0f,
  215.         2.0f / 63.0f,
  216.         2.0f / 127.0f,
  217.         2.0f / 255.0f,
  218.         2.0f / 511.0f,
  219.         2.0f / 1023.0f,
  220.         2.0f / 2047.0f,
  221.         2.0f / 4095.0f,
  222.         2.0f / 8191.0f,
  223.         2.0f / 16383.0f,
  224.         2.0f / 32767.0f,
  225.         2.0f / 65536.0f,
  226.         2.0f / 3.0f,        // grouping - 3 x 3 steps
  227.         2.0f / 5.0f,        // grouping - 3 x 5 steps
  228.         2.0f / 9.0f,        // grouping - 3 x 9 steps
  229.     };
  230.  
  231.     const unsigned nch = stereo ? 2 : 1;
  232.  
  233.     for(sb=0; sb<sblimit; ++sb) {
  234.         for(unsigned ch=0; ch<nch; ++ch) {
  235.             if (bitalloc[sb][ch]) {
  236.                 VDASSERT(bitalloc[sb][ch] >= 3);
  237.                 const float dq = sL2Dequant[bitalloc[sb][ch] - 3];
  238.                 float sf0 = dq*mL2Scalefactors[bits.get(6)];
  239.  
  240.                 scalefac[0][sb][ch] = sf0;
  241.  
  242.                 switch(scfsi[sb][ch]) {
  243.                 case 0:                    // 3 distinct scale factors
  244.                     scalefac[1][sb][ch] = dq*mL2Scalefactors[bits.get(6)];
  245.                     scalefac[2][sb][ch] = dq*mL2Scalefactors[bits.get(6)];
  246.                     break;
  247.                 case 1:                    // granules 0 and 1 share common scalefactor
  248.                     scalefac[1][sb][ch] = sf0;
  249.                     scalefac[2][sb][ch] = dq*mL2Scalefactors[bits.get(6)];
  250.                     break;
  251.                 case 3:                    // granules 1 and 2 share common scalefactor
  252.                     scalefac[1][sb][ch] = scalefac[2][sb][ch] = dq*mL2Scalefactors[bits.get(6)];
  253.                     break;
  254.                 case 2:                    // single scalefactor
  255.                     scalefac[1][sb][ch] = scalefac[2][sb][ch] = sf0;
  256.                     break;
  257.                 default:
  258.                     VDNEVERHERE;
  259.                 }
  260.             }
  261.         }
  262.     }
  263.  
  264.     // dequantize subband samples and run through polyphase
  265.     // (12*32 = 384 samples/frame)
  266.     //
  267.     // The layer I dequantization algorithm, according to 11172-3:
  268.     // 1) Grab bits as two's complement value.
  269.     // 2) Toggle MSB.
  270.     // 3) Divide by 2^(N-1) so fraction is in [-1, 1).
  271.     // 4) Compute y = (2^N / (2^N-1)) * (x + 2^(1-N)).
  272.     //
  273.     // Steps 1 and 2 essentially decode a biased value:
  274.     //    x = (getbits(N) - 2^(N-1)) / 2^(N-1)
  275.     //
  276.     // We can absorb the additional bias from step 4:
  277.     //    x' = (getbits(N) - 2^(N-1) + 1) / 2^(N-1)
  278.     //
  279.     // All ones as a sample is not valid.
  280.  
  281.     for(unsigned gr=0; gr<12; ++gr) {
  282.         unsigned part = gr >> 2;
  283.         float sample[3][2][32] = {0};
  284.         unsigned nch = 2;
  285.  
  286.         for(sb=0; sb<sblimit; ++sb) {
  287.             if (sb == bound)
  288.                 nch = 1;
  289.  
  290.             for(unsigned ch=0; ch<nch; ++ch) {
  291.                 if (unsigned n = bitalloc[sb][ch]) {
  292.                     int v0, v1, v2;
  293.  
  294.                     if (n <= 16) {
  295.                         int bias = 1 - (1<<(n-1));
  296.  
  297.                         v0 = (int)bits.get(n) + bias;
  298.                         v1 = (int)bits.get(n) + bias;
  299.                         v2 = (int)bits.get(n) + bias;
  300.  
  301.                         VDASSERT(v0-bias != ((1<<n)-1));
  302.                         VDASSERT(v1-bias != ((1<<n)-1));
  303.                         VDASSERT(v2-bias != ((1<<n)-1));
  304.                     } else {
  305.                         int v;
  306.  
  307.                         switch(n) {
  308.                         case 17:        // 3 x 3 (5 bits)
  309.                             v = (int)bits.get(5);
  310.                             VDASSERT(v < 27);
  311.                             v0 = mL2Ungroup3[v][0];
  312.                             v1 = mL2Ungroup3[v][1];
  313.                             v2 = mL2Ungroup3[v][2];
  314.                             break;
  315.                         case 18:        // 3 x 5 (7 bits)
  316.                             v = (int)bits.get(7);
  317.                             VDASSERT(v < 125);
  318.                             v0 = (v % 5) - 2;
  319.                             v1 = ((v / 5) % 5) - 2;
  320.                             v2 = ((v / 25) % 5) - 2;
  321.                             break;
  322.                         case 19:        // 3 x 9 (10 bits)
  323.                             v = (int)bits.get(10);
  324.                             VDASSERT(v < 729);
  325.                             v0 = (v % 9) - 4;
  326.                             v1 = ((v / 9) % 9) - 4;
  327.                             v2 = ((v / 81) % 9) - 4;
  328.                             break;
  329.                         default:
  330.                             VDNEVERHERE;
  331.                         }
  332.                     }
  333.  
  334.                     sample[0][ch][sb] = v0 * scalefac[part][sb][ch];
  335.                     sample[1][ch][sb] = v1 * scalefac[part][sb][ch];
  336.                     sample[2][ch][sb] = v2 * scalefac[part][sb][ch];
  337.                     if (stereo && sb >= bound) {
  338.                         sample[0][1][sb] = v0 * scalefac[part][sb][1];
  339.                         sample[1][1][sb] = v1 * scalefac[part][sb][1];
  340.                         sample[2][1][sb] = v2 * scalefac[part][sb][1];
  341.                     }
  342.                 }
  343.             }
  344.         }
  345.  
  346.         for(unsigned s=0; s<3; ++s) {
  347.             mpPolyphaseFilter->Generate(sample[s][0], stereo?sample[s][1]:NULL, mpSampleDst);
  348.             mpSampleDst += stereo ? 64 : 32;
  349.         }
  350.     }
  351.  
  352.     mSamplesDecoded = stereo ? 2304 : 1152;
  353.  
  354. #ifdef _DEBUG
  355.     VDASSERT(bits.avail() == expected_left);
  356. #endif
  357.  
  358.     return true;
  359. }
  360.